package com.divemotor.ventarepuestosinternet.service.impl;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.divemotor.ventarepuestosinternet.dao.AdministradorDAO;
import com.divemotor.ventarepuestosinternet.dao.SupervisorDAO;

import com.divemotor.ventarepuestosinternet.dao.UsuarioDAO;
import com.divemotor.ventarepuestosinternet.exception.DivemotorBusinessException;
import com.divemotor.ventarepuestosinternet.model.Departamento;
import com.divemotor.ventarepuestosinternet.model.Distrito;
import com.divemotor.ventarepuestosinternet.model.Perfil;
import com.divemotor.ventarepuestosinternet.model.Provincia;
import com.divemotor.ventarepuestosinternet.model.Sucursal;
import com.divemotor.ventarepuestosinternet.model.Supervisor;
import com.divemotor.ventarepuestosinternet.model.Usuario;
import com.divemotor.ventarepuestosinternet.service.AdministradorService;
import com.divemotor.ventarepuestosinternet.service.SupervisorService;
import com.divemotor.ventarepuestosinternet.service.VendedorService;
import com.divemotor.ventarepuestosinternet.util.Constantes;
import com.divemotor.ventarepuestosinternet.util.DatosDeSession;
import com.divemotor.ventarepuestosinternet.util.Encriptacion;
import com.divemotor.ventarepuestosinternet.util.FechasUtil;


@Service(value = "supervisorService")
@Transactional(rollbackFor=Exception.class)
public class SupervisorServiceImpl implements SupervisorService, Serializable {

	private static final long serialVersionUID = 1L;
	
	@Autowired
	private SupervisorDAO supervisorDAO;
	
	@Autowired
	private UsuarioDAO usuarioDAO;
	
	@Autowired
	private AdministradorDAO administradorDAO;

	@Autowired
	private AdministradorService administradorService;

	@Autowired
	private VendedorService vendedorService;

	
	
	@Override
	public List<Supervisor> listarSupervisores() throws DivemotorBusinessException {
		return supervisorDAO.listarTodos();
	}

	@Override
	public List<Supervisor> buscarUsuarios(Supervisor supervisor)throws DivemotorBusinessException {
		return supervisorDAO.buscarUsuarios(supervisor);
	}
	
	@Override
	public Supervisor obtenerPorId(Supervisor supervisor) throws DivemotorBusinessException {
		Supervisor supTlmrk=supervisorDAO.obtenerPorId(supervisor.getIdSupervisor());
		
		if (supTlmrk != null) {
			supTlmrk.getListaSucursal().size();
		}
		
		return supTlmrk;
	}
	
	@Override
	public Supervisor obtenerPorCodigo(Supervisor supervisor) throws DivemotorBusinessException {
		return supervisorDAO.obtenerPorCodigo(supervisor);
	}

	@Override
	public void insertar(Supervisor supervisor) throws DivemotorBusinessException {
		
		supervisor.setFechaCreacion(FechasUtil.obtenerFechaActual());
		supervisor.setUsuarioCreacion(DatosDeSession.obtenerUsuarioAutenticado());
		supervisor.getUsuario().setPais(DatosDeSession.obtenerPaisDelUsuarioAutenticado());
		supervisor.getUsuario().setContrasenia(Encriptacion.encriptarMD5(supervisor.getUsuario().getContrasenia()));
		
		Usuario user = usuarioDAO.obtenerPorUsuarioLogin(supervisor.getUsuario());
		 
		if(user!=null){
			 if(user.getListaPerfiles().size()==0){
			   user.setApellidos(supervisor.getUsuario().getApellidos());
			   user.setContrasenia(supervisor.getUsuario().getContrasenia());
			   user.setNombres(supervisor.getUsuario().getNombres());
			   user.setPais(supervisor.getUsuario().getPais());
			   user.setUsuario(supervisor.getUsuario().getUsuario());
			   user.setListaPerfiles(supervisor.getUsuario().getListaPerfiles());
		       supervisor.setUsuario(user);
			   supervisorDAO.insertar(supervisor);
			   usuarioDAO.actualizarUsuarioExistente(user);
			 }else{
			   user.setApellidos(supervisor.getUsuario().getApellidos());
			   user.setContrasenia(supervisor.getUsuario().getContrasenia());
			   user.setNombres(supervisor.getUsuario().getNombres());
			   user.setPais(supervisor.getUsuario().getPais());
			   user.setUsuario(supervisor.getUsuario().getUsuario());
			   List<Perfil> nuevaLista = user.getListaPerfiles();
		       nuevaLista.add(new Perfil(Constantes.ID_PERFIL_SUPERVISOR));
		       user.setListaPerfiles(nuevaLista);
		       supervisor.setUsuario(user);
			   supervisorDAO.insertar(supervisor);
			   usuarioDAO.actualizarUsuarioExistente(user);
			 }
		 }else{
			usuarioDAO.insertar(supervisor.getUsuario());
			supervisorDAO.insertar(supervisor);
		 }
	}

	@Override
	public void actualizar(Supervisor supervisor) throws DivemotorBusinessException {
	   supervisor.setFechaModificacion(FechasUtil.obtenerFechaActual());
	   supervisor.setUsuarioModificacion(DatosDeSession.obtenerUsuarioAutenticado());
	   Usuario usu = usuarioDAO.obtenerListadePerfiles(supervisor.getUsuario());
	   supervisor.getUsuario().setListaPerfiles(usu.getListaPerfiles());
	   usuarioDAO.actualizar(supervisor.getUsuario());
	   supervisorDAO.actualizar(supervisor);
	}
	
	@Override
	public void eliminar(Supervisor supervisor) throws DivemotorBusinessException {
		supervisor.setEstado(Constantes.ESTADO_ELIMINADO);
		supervisor.setUsuarioEliminacion(DatosDeSession.obtenerUsuarioAutenticado());
		supervisor.setFechaEliminacion(FechasUtil.obtenerFechaActual());
		List<Perfil> lsList = new ArrayList<Perfil>();
		supervisor.getUsuario().setListaPerfiles(lsList);
		supervisorDAO.eliminarConEstado(supervisor);
		usuarioDAO.eliminar(supervisor.getUsuario());
	}

	@Override
	public void listar() throws DivemotorBusinessException {
		supervisorDAO.listarTodos();
	}

	@Override
	public void eliminarPorUsuario(Usuario usuario) throws DivemotorBusinessException {
		Supervisor supervisor = obtenerPorIdusuario(usuario);
		
		if(supervisor != null){
			supervisor.setEstado(Constantes.ESTADO_ELIMINADO);
			List<Perfil> perfiles = new ArrayList<Perfil>();
			supervisor.getUsuario().setListaPerfiles(perfiles);
			usuarioDAO.actualizarUsuarioExistente(supervisor.getUsuario());
			supervisor.setUsuarioEliminacion(DatosDeSession.obtenerUsuarioAutenticado());
			supervisor.setFechaEliminacion(FechasUtil.obtenerFechaActual());
			supervisorDAO.eliminarPorUsuario(supervisor);
		}
	}

	private Supervisor obtenerPorIdusuario(Usuario usuario) {
		return supervisorDAO.obtenerPorIdusuario(usuario);
	}

	@Override
	public void migrarUsuario(Integer tipoDeusuario, Supervisor supervisor) throws DivemotorBusinessException {
		Usuario user = usuarioDAO.obtenerListadePerfiles(supervisor.getUsuario());
		List<Perfil>lstPerfilesAntiguo  = user.getListaPerfiles();
		List<Perfil> lstNueva = new ArrayList<Perfil>();
		
		for (int i = 0; i < lstPerfilesAntiguo.size(); i++) {
			if(!(lstPerfilesAntiguo.get(i).getIdPerfil().equals(tipoDeusuario))){
	   		 	lstNueva.add(lstPerfilesAntiguo.get(i));
	   	  	}
		}
		  
		lstNueva.add(new Perfil(Constantes.ID_PERFIL_SUPERVISOR));

		supervisor.getUsuario().setListaPerfiles(lstNueva);

		administradorService.eliminarPorUsuario(supervisor.getUsuario());
		vendedorService.eliminarPorUsuario(supervisor.getUsuario());
		supervisor.setUsuarioCreacion(DatosDeSession.obtenerUsuarioAutenticado());
		supervisor.setFechaCreacion(FechasUtil.obtenerFechaActual());
		supervisor.getUsuario().setPais(DatosDeSession.obtenerPaisDelUsuarioAutenticado());
		usuarioDAO.actualizarUsuarioExistente(supervisor.getUsuario()); 
		supervisorDAO.insertarSinRetornar(supervisor);	
	}

	@Override
	public Supervisor obtenerPorUsuario(Usuario user) throws DivemotorBusinessException {
		return supervisorDAO.obtenerPorIdusuario(user);
	}

	@Override
	public Supervisor obtenerSupervisorAutenticado() throws DivemotorBusinessException {
		return obtenerPorUsuario(DatosDeSession.obtenerUsuarioAutenticado());
	}

	@Override
	public List<Departamento> obtenerDepartamentosPorSupervisor() throws DivemotorBusinessException {
        Usuario user = new Usuario();
	    user = DatosDeSession.obtenerUsuarioAutenticado();
	    List<Departamento> listaDepartamentos  = supervisorDAO.obtenerDepartamentosPorSupervisor(user);
		return listaDepartamentos;
	}

	@Override
	public List<Provincia> obtenerProvinciasPorSupervisor(Integer idDepartamento) throws DivemotorBusinessException  {
		Usuario user = new Usuario();
		user = DatosDeSession.obtenerUsuarioAutenticado();
		List<Provincia> listaProvincias = supervisorDAO.obtenerProvinciasPorSupervisorDepartamento(user,idDepartamento);
		return listaProvincias;
	}

	@Override
	public List<Distrito> obtenerDistritosPorSupervisor(Integer idprovincia) throws DivemotorBusinessException {
		Usuario user = new Usuario();
		user = DatosDeSession.obtenerUsuarioAutenticado();
		List<Distrito> listaDistritos= supervisorDAO.obtenerDistritosPorSupervisorDepartamento(user,idprovincia);
		return listaDistritos;
	}

	@Override
	public List<Sucursal> obtenerListaSucursales(Usuario obtenerUsuarioAutenticado) throws DivemotorBusinessException {
		Supervisor supervisor =   supervisorDAO.obtenerPorIdusuario(obtenerUsuarioAutenticado);
		supervisor.getListaSucursal().size();
		return supervisor.getListaSucursal();
	}
	
}
